home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / emulator / bsvc-1.000 / bsvc-1 / bsvc-1.0.4 / src / Assemblers / 68kasm / insttable.c < prev    next >
C/C++ Source or Header  |  1995-07-26  |  26KB  |  849 lines
  1. /******************************************************************************
  2.  * $Id: insttable.c,v 1.2 1994/09/22 00:03:40 bmott Exp $
  3.  ******************************************************************************
  4.  *
  5.  *        INSTTABLE.C
  6.  *        Instruction Table for 68000 Assembler
  7.  *
  8.  * Description: This file contains two kinds of data structure declara-
  9.  *        tions: "flavor lists" and the instruction table. First
  10.  *        in the file are "flavor lists," one for each different
  11.  *        instruction. Then comes the instruction table, which
  12.  *        contains the mnemonics of the various instructions, a
  13.  *        pointer to the flavor list for each instruction, and
  14.  *        other data. Finally, the variable tableSize is
  15.  *        initialized to contain the number of instructions in
  16.  *        the table. 
  17.  *
  18.  *      Author: Paul McKee
  19.  *        ECE492    North Carolina State University
  20.  *
  21.  *        Date:    12/13/86
  22.  *
  23.  *   Copyright 1990-1991 North Carolina State University. All Rights Reserved.
  24.  *
  25.  ******************************************************************************
  26.  * $Log: insttable.c,v $
  27.  * Revision 1.2  1994/09/22  00:03:40  bmott
  28.  * Added BREAK instruction
  29.  *
  30.  * Revision 1.1  1994/08/30  00:00:49  bmott
  31.  * Initial revision
  32.  *
  33.  *****************************************************************************/
  34.  
  35.  
  36. /******************************************************************************
  37.  
  38.           HOW THE INSTRUCTION TABLE AND FLAVOR LISTS ARE USED
  39.  
  40.      The procedure which instLookup() and assemble() use to look up
  41. and verify an instruction (or directive) is as follows. Once the
  42. mnemonic of the instruction has been parsed and stripped of its size
  43. code and trailing spaces, the instLookup() does a binary search on the
  44. instruction table to determine if the mnemonic is present. If it is
  45. not found, then the INV_OPCODE error results. If the mnemonic is
  46. found, then assemble() examines the field parseFlag for that entry.
  47. This flag is TRUE if the mnemonic represents a normal instruction that
  48. can be parsed by assemble(); it is FALSE if the instruction's operands
  49. have an unusual format (as is the case for MOVEM and DC). 
  50.  
  51.       If the parseFlag is TRUE, then assemble will parse the
  52. instruction's operands, check them for validity, and then pass the
  53. data to the proper routine which will build the instruction. To do
  54. this it uses the pointer in the instruction table to the instruction's
  55. "flavor list" and scans through the list until it finds an particular
  56. "flavor" of the instruction which matches the addressing mode(s)
  57. specified.  If it finds such a flavor, it checks the instruction's
  58. size code and passes the instruction mask for the appropriate size 
  59. (there are three masks for each flavor) to the building routine
  60. through a pointer in the flavor list for that flavor. 
  61.  
  62. ******************************************************************************/
  63.  
  64.  
  65. #include <stdio.h>
  66. #include "asm.h"
  67.  
  68.  
  69. /* Declarations of the routines that build instructions */
  70.  
  71. int move(), zeroOp(), oneOp(), shiftReg(), twoReg(), arithReg(), 
  72.     arithAddr(), immedInst(), quickMath(), moveReg(), moves(), movep(),
  73.     staticBit(), movec(), trap(), moveq(), branch(), movem(), reg(),
  74.     immedToCCR(), immedWord(), dbcc(), scc(), exg(), oneReg(), moveUSP(),
  75.     link();
  76.  
  77.  
  78. /* Declarations of the routines that handle directives */
  79.  
  80. int org(), equ(), set(), End(), dc(), dcb(), ds();
  81.  
  82.  
  83. /* Definitions of addressing mode masks for various classes of references */
  84.  
  85. #define Data    (DnDirect | AnInd | AnIndPost | AnIndPre | AnIndDisp \
  86.          | AnIndIndex | AbsShort | AbsLong | PCDisp | PCIndex \
  87.          | Immediate)
  88.  
  89. #define Memory    (AnInd | AnIndPost | AnIndPre | AnIndDisp | AnIndIndex \
  90.          | AbsShort | AbsLong | PCDisp | PCIndex | Immediate)
  91.  
  92. #define Control    (AnInd | AnIndDisp | AnIndIndex | AbsShort | AbsLong | PCDisp \
  93.          | PCIndex)
  94.  
  95. #define Alter    (DnDirect | AnDirect | AnInd | AnIndPost | AnIndPre \
  96.          | AnIndDisp | AnIndIndex | AbsShort | AbsLong)
  97.  
  98. #define All    (Data | Memory | Control | Alter)
  99. #define DataAlt    (Data & Alter)
  100. #define MemAlt    (Memory & Alter)
  101. #define Absolute (AbsLong | AbsShort)
  102. #define GenReg    (DnDirect | AnDirect)
  103.  
  104.  
  105. /* Define size code masks for instructions that allow more than one size */
  106.  
  107. #define BW    (BYTE | WORD)
  108. #define WL    (WORD | LONG)
  109. #define BWL    (BYTE | WORD | LONG)
  110. #define BL    (BYTE | LONG)
  111.  
  112.  
  113. /* Define the "flavor lists" for each different instruction */
  114.  
  115. flavor abcdfl[] = {
  116.     { DnDirect, DnDirect, BYTE, twoReg, 0xC100, 0xC100, 0 },
  117.     { AnIndPre, AnIndPre, BYTE, twoReg, 0xC108, 0xC108, 0 }
  118.        };
  119.  
  120. flavor addfl[] = {
  121.     { Immediate, DataAlt, BWL, immedInst, 0x0600, 0x0640, 0x0680 },
  122.     { Immediate, AnDirect, WL, quickMath, 0, 0x5040, 0x5080 },
  123.     { All, DnDirect, BWL, arithReg, 0xD000, 0xD040, 0xD080 },
  124.     { DnDirect, MemAlt, BWL, arithAddr, 0xD100, 0xD140, 0xD180 },
  125.     { All, AnDirect, WL, arithReg, 0, 0xD0C0, 0xD1C0 },
  126.        };
  127.  
  128. flavor addafl[] = {
  129.     { All, AnDirect, WL, arithReg, 0, 0xD0C0, 0xD1C0 },
  130.        };
  131.  
  132. flavor addifl[] = {
  133.     { Immediate, DataAlt, BWL, immedInst, 0x0600, 0x0640, 0x0680 }
  134.        };
  135.  
  136. flavor addqfl[] = {
  137.     { Immediate, DataAlt, BWL, quickMath, 0x5000, 0x5040, 0x5080 },
  138.     { Immediate, AnDirect, WL, quickMath, 0, 0x5040, 0x5080 }
  139.        };
  140.  
  141. flavor addxfl[] = {
  142.     { DnDirect, DnDirect, BWL, twoReg, 0xD100, 0xD140, 0xD180 },
  143.     { AnIndPre, AnIndPre, BWL, twoReg, 0xD108, 0xD148, 0xD188 }
  144.        };
  145.  
  146. flavor andfl[] = {
  147.     { Data, DnDirect, BWL, arithReg, 0xC000, 0xC040, 0xC080 },
  148.     { DnDirect, MemAlt, BWL, arithAddr, 0xC100, 0xC140, 0xC180 },
  149.     { Immediate, DataAlt, BWL, immedInst, 0x0200, 0x0240, 0x0280 }
  150.        };
  151.  
  152. flavor andifl[] = {
  153.     { Immediate, DataAlt, BWL, immedInst, 0x0200, 0x0240, 0x0280 },
  154.     { Immediate, CCRDirect, BYTE, immedToCCR, 0x023C, 0x023C, 0 },
  155.     { Immediate, SRDirect, WORD, immedWord, 0, 0x027C, 0 }
  156.        };
  157.  
  158. flavor aslfl[] = {
  159.     { MemAlt, 0, WORD, oneOp, 0, 0xE1C0, 0 },
  160.     { DnDirect, DnDirect, BWL, shiftReg, 0xE120, 0xE160, 0xE1A0 },
  161.     { Immediate, DnDirect, BWL, shiftReg, 0xE100, 0xE140, 0xE180 }
  162.        };
  163.  
  164. flavor asrfl[] = {
  165.     { MemAlt, 0, WORD, oneOp, 0, 0xE0C0, 0 },
  166.     { DnDirect, DnDirect, BWL, shiftReg, 0xE020, 0xE060, 0xE0A0 },
  167.     { Immediate, DnDirect, BWL, shiftReg, 0xE000, 0xE040, 0xE080 }
  168.        };
  169.  
  170. flavor bccfl[] = {
  171.     { Absolute, 0, SHORT | LONG, branch, 0x6400, 0x6400, 0x6400 }
  172.        };
  173.  
  174. flavor bchgfl[] = {
  175.     { DnDirect, MemAlt, BYTE, arithAddr, 0x0140, 0x0140, 0 },
  176.     { DnDirect, DnDirect, LONG, arithAddr, 0, 0x0140, 0x0140 },
  177.     { Immediate, MemAlt, BYTE, staticBit, 0x0840, 0x0840, 0 },
  178.     { Immediate, DnDirect, LONG, staticBit, 0, 0x0840, 0x0840 }
  179.        };
  180.  
  181. flavor bclrfl[] = {
  182.     { DnDirect, MemAlt, BYTE, arithAddr, 0x0180, 0x0180, 0 },
  183.     { DnDirect, DnDirect, LONG, arithAddr, 0, 0x0180, 0x0180 },
  184.     { Immediate, MemAlt, BYTE, staticBit, 0x0880, 0x0880, 0 },
  185.     { Immediate, DnDirect, LONG, staticBit, 0, 0x0880, 0x0880 }
  186.        };
  187.  
  188. flavor bcsfl[] = {
  189.     { Absolute, 0, SHORT | LONG, branch, 0x6500, 0x6500, 0x6500 }
  190.        };
  191.  
  192. flavor beqfl[] = {
  193.     { Absolute, 0, SHORT | LONG, branch, 0x6700, 0x6700, 0x6700 }
  194.        };
  195.  
  196. flavor bgefl[] = {
  197.     { Absolute, 0, SHORT | LONG, branch, 0x6C00, 0x6C00, 0x6C00 }
  198.        };
  199.  
  200. flavor bgtfl[] = {
  201.     { Absolute, 0, SHORT | LONG, branch, 0x6E00, 0x6E00, 0x6E00 }
  202.        };
  203.  
  204. flavor bhifl[] = {
  205.     { Absolute, 0, SHORT | LONG, branch, 0x6200, 0x6200, 0x6200 }
  206.        };
  207.  
  208. flavor bhsfl[] = {
  209.     { Absolute, 0, SHORT | LONG, branch, 0x6400, 0x6400, 0x6400 }
  210.        };
  211.  
  212. flavor blefl[] = {
  213.     { Absolute, 0, SHORT | LONG, branch, 0x6f00, 0x6F00, 0x6F00 }
  214.        };
  215.  
  216. flavor blofl[] = {
  217.     { Absolute, 0, SHORT | LONG, branch, 0x6500, 0x6500, 0x6500 }
  218.        };
  219.  
  220. flavor blsfl[] = {
  221.     { Absolute, 0, SHORT | LONG, branch, 0x6300, 0x6300, 0x6300 }
  222.        };
  223.  
  224. flavor bltfl[] = {
  225.     { Absolute, 0, SHORT | LONG, branch, 0x6d00, 0x6D00, 0x6D00 }
  226.        };
  227.  
  228. flavor bmifl[] = {
  229.     { Absolute, 0, SHORT | LONG, branch, 0x6b00, 0x6B00, 0x6B00 }
  230.        };
  231.  
  232. flavor bnefl[] = {
  233.     { Absolute, 0, SHORT | LONG, branch, 0x6600, 0x6600, 0x6600 }
  234.        };
  235.  
  236. flavor bplfl[] = {
  237.     { Absolute, 0, SHORT | LONG, branch, 0x6a00, 0x6A00, 0x6A00 }
  238.        };
  239.  
  240. flavor brafl[] = {
  241.     { Absolute, 0, SHORT | LONG, branch, 0x6000, 0x6000, 0x6000 }
  242.        };
  243.  
  244. flavor bsetfl[] = {
  245.     { DnDirect, MemAlt, BYTE, arithAddr, 0x01C0, 0x01C0, 0 },
  246.     { DnDirect, DnDirect, LONG, arithAddr, 0, 0x01C0, 0x01C0 },
  247.     { Immediate, MemAlt, BYTE, staticBit, 0x08C0, 0x08C0, 0 },
  248.     { Immediate, DnDirect, LONG, staticBit, 0, 0x08C0, 0x08C0 }
  249.        };
  250.  
  251. flavor bsrfl[] = {
  252.     { Absolute, 0, SHORT | LONG, branch, 0x6100, 0x6100, 0x6100 }
  253.        };
  254.  
  255. flavor btstfl[] = {
  256.     { DnDirect, Memory, BYTE, arithAddr, 0x0100, 0x0100, 0 },
  257.     { DnDirect, DnDirect, LONG, arithAddr, 0, 0x0100, 0x0100 },
  258.     { Immediate, Memory, BYTE, staticBit, 0x0800, 0x0800, 0 },
  259.     { Immediate, DnDirect, LONG, staticBit, 0, 0x0800, 0x0800 }
  260.        };
  261.  
  262. flavor bvcfl[] = {
  263.     { Absolute, 0, SHORT | LONG, branch, 0x6800, 0x6800, 0x6800 }
  264.        };
  265.  
  266. flavor bvsfl[] = {
  267.     { Absolute, 0, SHORT | LONG, branch, 0x6900, 0x6900, 0x6900 }
  268.        };
  269.  
  270. flavor chkfl[] = {
  271.     { Data, DnDirect, WORD, arithReg, 0, 0x4180, 0 }
  272.        };
  273.  
  274. flavor clrfl[] = {
  275.     { DataAlt, 0, BWL, oneOp, 0x4200, 0x4240, 0x4280 }
  276.        };
  277.  
  278. flavor cmpfl[] = {
  279.     { All, DnDirect, BWL, arithReg, 0xB000, 0xB040, 0xB080 },
  280.     { All, AnDirect, WL, arithReg, 0, 0xB0C0, 0xB1C0 },
  281.     { Immediate, DataAlt, BWL, immedInst, 0x0C00, 0x0C40, 0x0C80 }
  282.        };
  283.  
  284. flavor cmpafl[] = {
  285.     { All, AnDirect, WL, arithReg, 0, 0xB0C0, 0xB1C0 }
  286.        };
  287.  
  288. flavor cmpifl[] = {
  289.     { Immediate, DataAlt, BWL, immedInst, 0x0C00, 0x0C40, 0x0C80 }
  290.        };
  291.  
  292. flavor cmpmfl[] = {
  293.     { AnIndPost, AnIndPost, BWL, twoReg, 0xB108, 0xB148, 0xB188 }
  294.        };
  295.  
  296. flavor dbccfl[] = {
  297.     { DnDirect, Absolute, WORD, dbcc, 0, 0x54C8, 0 }
  298.        };
  299.  
  300. flavor dbcsfl[] = {
  301.     { DnDirect, Absolute, WORD, dbcc, 0, 0x55C8, 0 }
  302.        };
  303.  
  304. flavor dbeqfl[] = {
  305.     { DnDirect, Absolute, WORD, dbcc, 0, 0x57C8, 0 }
  306.        };
  307.  
  308. flavor dbffl[] = {
  309.     { DnDirect, Absolute, WORD, dbcc, 0, 0x51C8, 0 }
  310.        };
  311.  
  312. flavor dbgefl[] = {
  313.     { DnDirect, Absolute, WORD, dbcc, 0, 0x5CC8, 0 }
  314.        };
  315.  
  316. flavor dbgtfl[] = {
  317.     { DnDirect, Absolute, WORD, dbcc, 0, 0x5EC8, 0 }
  318.        };
  319.  
  320. flavor dbhifl[] = {
  321.     { DnDirect, Absolute, WORD, dbcc, 0, 0x52C8, 0 }
  322.        };
  323.  
  324. flavor dbhsfl[] = {
  325.     { DnDirect, Absolute, WORD, dbcc, 0, 0x54C8, 0 }
  326.        };
  327.  
  328. flavor dblefl[] = {
  329.     { DnDirect, Absolute, WORD, dbcc, 0, 0x5FC8, 0 }
  330.        };
  331.  
  332. flavor dblofl[] = {
  333.     { DnDirect, Absolute, WORD, dbcc, 0, 0x55C8, 0 }
  334.        };
  335.  
  336. flavor dblsfl[] = {
  337.     { DnDirect, Absolute, WORD, dbcc, 0, 0x53C8, 0 }
  338.        };
  339.  
  340. flavor dbltfl[] = {
  341.     { DnDirect, Absolute, WORD, dbcc, 0, 0x5DC8, 0 }
  342.        };
  343.  
  344. flavor dbmifl[] = {
  345.     { DnDirect, Absolute, WORD, dbcc, 0, 0x5BC8, 0 }
  346.        };
  347.  
  348. flavor dbnefl[] = {
  349.     { DnDirect, Absolute, WORD, dbcc, 0, 0x56C8, 0 }
  350.        };
  351.  
  352. flavor dbplfl[] = {
  353.     { DnDirect, Absolute, WORD, dbcc, 0, 0x5AC8, 0 }
  354.        };
  355.  
  356. flavor dbrafl[] = {
  357.     { DnDirect, Absolute, WORD, dbcc, 0, 0x51C8, 0 }
  358.        };
  359.  
  360. flavor dbtfl[] = {
  361.     { DnDirect, Absolute, WORD, dbcc, 0, 0x50C8, 0 }
  362.        };
  363.  
  364. flavor dbvcfl[] = {
  365.     { DnDirect, Absolute, WORD, dbcc, 0, 0x58C8, 0 }
  366.        };
  367.  
  368. flavor dbvsfl[] = {
  369.     { DnDirect, Absolute, WORD, dbcc, 0, 0x59C8, 0 }
  370.        };
  371.  
  372. flavor divsfl[] = {
  373.     { Data, DnDirect, WORD, arithReg, 0, 0x81C0, 0 }
  374.        };
  375.  
  376. flavor divufl[] = {
  377.     { Data, DnDirect, WORD, arithReg, 0, 0x80C0, 0 }
  378.        };
  379.  
  380. flavor eorfl[] = {
  381.     { DnDirect, DataAlt, BWL, arithAddr, 0xB100, 0xB140, 0xB180 },
  382.     { Immediate, DataAlt, BWL, immedInst, 0x0A00, 0x0A40, 0x0A80 }
  383.        };
  384.  
  385. flavor eorifl[] = {
  386.     { Immediate, DataAlt, BWL, immedInst, 0x0A00, 0x0A40, 0x0A80 },
  387.     { Immediate, CCRDirect, BYTE, immedToCCR, 0x0A3C, 0x0A3C, 0 },
  388.     { Immediate, SRDirect, WORD, immedWord, 0, 0x0A7C, 0 }
  389.        };
  390.  
  391. flavor exgfl[] = {
  392.     { DnDirect, DnDirect, LONG, exg, 0, 0xC140, 0xC140 },
  393.     { AnDirect, AnDirect, LONG, exg, 0, 0xC148, 0xC148 },
  394.     { GenReg, GenReg, LONG, exg, 0, 0xC188, 0xC188 }
  395.        };
  396.  
  397. flavor extfl[] = {
  398.     { DnDirect, 0, WL, oneReg, 0, 0x4880, 0x48C0 }
  399.        };
  400.  
  401. flavor illegalfl[] = {
  402.     { 0, 0, 0, zeroOp, 0, 0x4AFC, 0 }
  403.        };
  404.  
  405. flavor jmpfl[] = {
  406.     { Control, 0, 0, oneOp, 0, 0x4EC0, 0 }
  407.        };
  408.  
  409. flavor jsrfl[] = {
  410.     { Control, 0, 0, oneOp, 0, 0x4E80, 0 }
  411.        };
  412.  
  413. flavor leafl[] = {
  414.     { Control, AnDirect, LONG, arithReg, 0, 0x41C0, 0x41C0 }
  415.        };
  416.  
  417. flavor linkfl[] = {
  418.     { AnDirect, Immediate, 0, link, 0, 0x4E50, 0 }
  419.        };
  420.  
  421. flavor lslfl[] = {
  422.     { MemAlt, 0, WORD, oneOp, 0, 0xE3C0, 0 },
  423.     { DnDirect, DnDirect, BWL, shiftReg, 0xE128, 0xE168, 0xE1A8 },
  424.     { Immediate, DnDirect, BWL, shiftReg, 0xE108, 0xE148, 0xE188 }
  425.        };
  426.  
  427. flavor lsrfl[] = {
  428.     { MemAlt, 0, WORD, oneOp, 0, 0xE2C0, 0 },
  429.     { DnDirect, DnDirect, BWL, shiftReg, 0xE028, 0xE068, 0xE0A8 },
  430.     { Immediate, DnDirect, BWL, shiftReg, 0xE008, 0xE048, 0xE088 }
  431.        };
  432.  
  433. flavor movefl[] = {
  434.     { All, DataAlt, BWL, move, 0x1000, 0x3000, 0x2000 },
  435.     { All, AnDirect, WL, move, 0, 0x3000, 0x2000 },
  436.     { Data, CCRDirect, WORD, oneOp, 0, 0x44C0, 0 },
  437.     { Data, SRDirect, WORD, oneOp, 0, 0x46C0, 0 },
  438.     { CCRDirect, DataAlt, WORD, moveReg, 0, 0x42C0, 0 },
  439.     { SRDirect, DataAlt, WORD, moveReg, 0, 0x40C0, 0 },
  440.     { AnDirect, USPDirect, LONG, moveUSP, 0, 0x4E60, 0x4E60 },
  441.     { USPDirect, AnDirect, LONG, moveUSP, 0, 0x4E68, 0x4E68 }
  442.        };
  443.  
  444. flavor moveafl[] = {
  445.     { All, AnDirect, WL, move, 0, 0x3000, 0x2000 }
  446.        };
  447.  
  448. flavor movecfl[] = {
  449.     { SFCDirect | DFCDirect | USPDirect | VBRDirect,
  450.            GenReg, LONG, movec, 0, 0x4E7A, 0x4E7A },
  451.     { GenReg, SFCDirect | DFCDirect | USPDirect | VBRDirect,
  452.            LONG, movec, 0, 0x4E7B, 0x4E7B }
  453.        };
  454.  
  455. flavor movepfl[] = {
  456.     { DnDirect, AnIndDisp, WL, movep, 0, 0x0188, 0x01C8 },
  457.     { AnIndDisp, DnDirect, WL, movep, 0, 0x0108, 0x0148 },
  458.     { DnDirect, AnInd, WL, movep, 0, 0x0188, 0x01C8 },
  459.     { AnInd, DnDirect, WL, movep, 0, 0x0108, 0x0148 }
  460.        };
  461.  
  462. flavor moveqfl[] = {
  463.     { Immediate, DnDirect, LONG, moveq, 0, 0x7000, 0x7000 }
  464.        };
  465.  
  466. flavor movesfl[] = {
  467.     { GenReg, MemAlt, BWL, moves, 0x0E00, 0x0E40, 0x0E80 },
  468.     { MemAlt, GenReg, BWL, moves, 0x0E00, 0x0E40, 0x0E80 }
  469.        };
  470.  
  471. flavor mulsfl[] = {
  472.     { Data, DnDirect, WORD, arithReg, 0, 0xC1C0, 0 }
  473.        };
  474.  
  475. flavor mulufl[] = {
  476.     { Data, DnDirect, WORD, arithReg, 0, 0xC0C0, 0 }
  477.        };
  478.  
  479. flavor nbcdfl[] = {
  480.     { DataAlt, 0, BYTE, oneOp, 0x4800, 0x4800, 0 }
  481.        };
  482.  
  483. flavor negfl[] = {
  484.     { DataAlt, 0, BWL, oneOp, 0x4400, 0x4440, 0x4480 }
  485.        };
  486.  
  487. flavor negxfl[] = {
  488.     { DataAlt, 0, BWL, oneOp, 0x4000, 0x4040, 0x4080 }
  489.        };
  490.  
  491. flavor nopfl[] = {
  492.     { 0, 0, 0, zeroOp, 0, 0x4E71, 0 }
  493.        };
  494.  
  495. flavor notfl[] = {
  496.     { DataAlt, 0, BWL, oneOp, 0x4600, 0x4640, 0x4680 }
  497.        };
  498.  
  499. flavor orfl[] = {
  500.     { Data, DnDirect, BWL, arithReg, 0x8000, 0x8040, 0x8080 },
  501.     { DnDirect, MemAlt, BWL, arithAddr, 0x8100, 0x8140, 0x8180 },
  502.     { Immediate, DataAlt, BWL, immedInst, 0x0000, 0x0040, 0x0080 }
  503.        };
  504.  
  505. flavor orifl[] = {
  506.     { Immediate, DataAlt, BWL, immedInst, 0x0000, 0x0040, 0x0080 },
  507.     { Immediate, CCRDirect, BYTE, immedToCCR, 0x003C, 0x003C, 0 },
  508.     { Immediate, SRDirect, WORD, immedWord, 0, 0x007C, 0 }
  509.        };
  510.  
  511. flavor peafl[] = {
  512.     { Control, 0, LONG, oneOp, 0, 0x4840, 0x4840 }
  513.        };
  514.  
  515. flavor resetfl[] = {
  516.     { 0, 0, 0, zeroOp, 0, 0x4E70, 0 }
  517.        };
  518.  
  519. flavor rolfl[] = {
  520.     { MemAlt, 0, WORD, oneOp, 0, 0xE7C0, 0 },
  521.     { DnDirect, DnDirect, BWL, shiftReg, 0xE138, 0xE178, 0xE1B8 },
  522.     { Immediate, DnDirect, BWL, shiftReg, 0xE118, 0xE158, 0xE198 }
  523.        };
  524.  
  525. flavor rorfl[] = {
  526.     { MemAlt, 0, WORD, oneOp, 0, 0xE6C0, 0 },
  527.     { DnDirect, DnDirect, BWL, shiftReg, 0xE038, 0xE078, 0xE0B8 },
  528.     { Immediate, DnDirect, BWL, shiftReg, 0xE018, 0xE058, 0xE098 }
  529.        };
  530.  
  531. flavor roxlfl[] = {
  532.     { MemAlt, 0, WORD, oneOp, 0, 0xE5C0, 0 },
  533.     { DnDirect, DnDirect, BWL, shiftReg, 0xE130, 0xE170, 0xE1B0 },
  534.     { Immediate, DnDirect, BWL, shiftReg, 0xE110, 0xE150, 0xE190 }
  535.        };
  536.  
  537. flavor roxrfl[] = {
  538.     { MemAlt, 0, WORD, oneOp, 0, 0xE4C0, 0 },
  539.     { DnDirect, DnDirect, BWL, shiftReg, 0xE030, 0xE070, 0xE0B0 },
  540.     { Immediate, DnDirect, BWL, shiftReg, 0xE010, 0xE050, 0xE090 }
  541.        };
  542.  
  543. flavor rtdfl[] = {
  544.     { Immediate, 0, 0, immedWord, 0, 0x4E74, 0 }
  545.        };
  546.  
  547. flavor rtefl[] = {
  548.     { 0, 0, 0, zeroOp, 0, 0x4E73, 0 }
  549.        };
  550.  
  551. flavor rtrfl[] = {
  552.     { 0, 0, 0, zeroOp, 0, 0x4E77, 0 }
  553.        };
  554.  
  555. flavor rtsfl[] = {
  556.     { 0, 0, 0, zeroOp, 0, 0x4E75, 0 }
  557.        };
  558.  
  559. flavor sbcdfl[] = {
  560.     { DnDirect, DnDirect, BYTE, twoReg, 0x8100, 0x8100, 0 },
  561.     { AnIndPre, AnIndPre, BYTE, twoReg, 0x8108, 0x8108, 0 }
  562.        };
  563.  
  564. flavor sccfl[] = {
  565.     { DataAlt, 0, BYTE, scc, 0x54C0, 0x54C0, 0 }
  566.        };
  567.  
  568. flavor scsfl[] = {
  569.     { DataAlt, 0, BYTE, scc, 0x55C0, 0x55C0, 0 }
  570.        };
  571.  
  572. flavor seqfl[] = {
  573.     { DataAlt, 0, BYTE, scc, 0x57C0, 0x57C0, 0 }
  574.        };
  575.  
  576. flavor sffl[] = {
  577.     { DataAlt, 0, BYTE, scc, 0x51C0, 0x51C0, 0 }
  578.        };
  579.  
  580. flavor sgefl[] = {
  581.     { DataAlt, 0, BYTE, scc, 0x5CC0, 0x5CC0, 0 }
  582.        };
  583.  
  584. flavor sgtfl[] = {
  585.     { DataAlt, 0, BYTE, scc, 0x5EC0, 0x5EC0, 0 }
  586.        };
  587.  
  588. flavor shifl[] = {
  589.     { DataAlt, 0, BYTE, scc, 0x52C0, 0x52C0, 0 }
  590.        };
  591.  
  592. flavor shsfl[] = {
  593.     { DataAlt, 0, BYTE, scc, 0x54C0, 0x54C0, 0 }
  594.        };
  595.  
  596. flavor slefl[] = {
  597.     { DataAlt, 0, BYTE, scc, 0x5FC0, 0x5FC0, 0 }
  598.        };
  599.  
  600. flavor slofl[] = {
  601.     { DataAlt, 0, BYTE, scc, 0x55C0, 0x55C0, 0 }
  602.        };
  603.  
  604. flavor slsfl[] = {
  605.     { DataAlt, 0, BYTE, scc, 0x53C0, 0x53C0, 0 }
  606.        };
  607.  
  608. flavor sltfl[] = {
  609.     { DataAlt, 0, BYTE, scc, 0x5DC0, 0x5DC0, 0 }
  610.        };
  611.  
  612. flavor smifl[] = {
  613.     { DataAlt, 0, BYTE, scc, 0x5BC0, 0x5BC0, 0 }
  614.        };
  615.  
  616. flavor snefl[] = {
  617.     { DataAlt, 0, BYTE, scc, 0x56C0, 0x56C0, 0 }
  618.        };
  619.  
  620. flavor splfl[] = {
  621.     { DataAlt, 0, BYTE, scc, 0x5AC0, 0x5AC0, 0 }
  622.        };
  623.  
  624. flavor stfl[] = {
  625.     { DataAlt, 0, BYTE, scc, 0x50C0, 0x50C0, 0 }
  626.        };
  627.  
  628. flavor stopfl[] = {
  629.     { Immediate, 0, 0, immedWord, 0, 0x4E72, 0 }
  630.        };
  631.  
  632. flavor subfl[] = {
  633.     { Immediate, DataAlt, BWL, immedInst, 0x0400, 0x0440, 0x0480 },
  634.     { Immediate, AnDirect, WL, quickMath, 0, 0x5140, 0x5180 },
  635.     { All, DnDirect, BWL, arithReg, 0x9000, 0x9040, 0x9080 },
  636.     { DnDirect, MemAlt, BWL, arithAddr, 0x9100, 0x9140, 0x9180 },
  637.     { All, AnDirect, WL, arithReg, 0, 0x90C0, 0x91C0 },
  638.        };
  639.  
  640. flavor subafl[] = {
  641.     { All, AnDirect, WL, arithReg, 0, 0x90C0, 0x91C0 }
  642.        };
  643.  
  644. flavor subifl[] = {
  645.     { Immediate, DataAlt, BWL, immedInst, 0x0400, 0x0440, 0x0480 }
  646.        };
  647.  
  648. flavor subqfl[] = {
  649.     { Immediate, DataAlt, BWL, quickMath, 0x5100, 0x5140, 0x5180 },
  650.     { Immediate, AnDirect, WL, quickMath, 0, 0x5140, 0x5180 }
  651.        };
  652.  
  653. flavor subxfl[] = {
  654.     { DnDirect, DnDirect, BWL, twoReg, 0x9100, 0x9140, 0x9180 },
  655.     { AnIndPre, AnIndPre, BWL, twoReg, 0x9108, 0x9148, 0x9188 }
  656.        };
  657.  
  658. flavor svcfl[] = {
  659.     { DataAlt, 0, BYTE, scc, 0x58C0, 0x58C0, 0 }
  660.        };
  661.  
  662. flavor svsfl[] = {
  663.     { DataAlt, 0, BYTE, scc, 0x59C0, 0x59C0, 0 }
  664.        };
  665.  
  666. flavor swapfl[] = {
  667.     { DnDirect, 0, WORD, oneReg, 0, 0x4840, 0 }
  668.        };
  669.  
  670. flavor tasfl[] = {
  671.     { DataAlt, 0, BYTE, oneOp, 0x4AC0, 0x4AC0, 0 }
  672.        };
  673.  
  674. flavor trapfl[] = {
  675.     { Immediate, 0, 0, trap, 0, 0x4E40, 0 }
  676.        };
  677.  
  678. flavor trapvfl[] = {
  679.     { 0, 0, 0, zeroOp, 0, 0x4E76, 0 }
  680.        };
  681.  
  682. flavor tstfl[] = {
  683.     { DataAlt, 0, BWL, oneOp, 0x4A00, 0x4A40, 0x4A80 }
  684.        };
  685.  
  686. flavor unlkfl[] = {
  687.     { AnDirect, 0, 0, oneReg, 0, 0x4E58, 0 }
  688.        };
  689.  
  690. flavor breakfl[] = {
  691.     { 0, 0, 0, zeroOp, 0, 0x4848, 0 }
  692.        };
  693.  
  694.  
  695. /* Define a macro to compute the length of a flavor list */
  696.  
  697. #define flavorCount(flavorArray) (sizeof(flavorArray)/sizeof(flavor))
  698.  
  699.  
  700. /* The instruction table itself... */
  701.  
  702. instruction instTable[] = {
  703.     { "ABCD", abcdfl, flavorCount(abcdfl), TRUE, NULL },
  704.     { "ADD", addfl, flavorCount(addfl), TRUE, NULL },
  705.     { "ADDA", addafl, flavorCount(addafl), TRUE, NULL },
  706.     { "ADDI", addifl, flavorCount(addifl), TRUE, NULL },
  707.     { "ADDQ", addqfl, flavorCount(addqfl), TRUE, NULL },
  708.     { "ADDX", addxfl, flavorCount(addxfl), TRUE, NULL },
  709.     { "AND", andfl, flavorCount(andfl), TRUE, NULL },
  710.     { "ANDI", andifl, flavorCount(andifl), TRUE, NULL },
  711.     { "ASL", aslfl, flavorCount(aslfl), TRUE, NULL },
  712.     { "ASR", asrfl, flavorCount(aslfl), TRUE, NULL },
  713.     { "BCC", bccfl, flavorCount(bccfl), TRUE, NULL },
  714.     { "BCHG", bchgfl, flavorCount(bchgfl), TRUE, NULL },
  715.     { "BCLR", bclrfl, flavorCount(bclrfl), TRUE, NULL },
  716.     { "BCS", bcsfl, flavorCount(bcsfl), TRUE, NULL },
  717.     { "BEQ", beqfl, flavorCount(beqfl), TRUE, NULL },
  718.     { "BGE", bgefl, flavorCount(bgefl), TRUE, NULL },
  719.     { "BGT", bgtfl, flavorCount(bgtfl), TRUE, NULL },
  720.     { "BHI", bhifl, flavorCount(bhifl), TRUE, NULL },
  721.     { "BHS", bccfl, flavorCount(bccfl), TRUE, NULL },
  722.     { "BLE", blefl, flavorCount(blefl), TRUE, NULL },
  723.     { "BLO", bcsfl, flavorCount(bcsfl), TRUE, NULL },
  724.     { "BLS", blsfl, flavorCount(blsfl), TRUE, NULL },
  725.     { "BLT", bltfl, flavorCount(bltfl), TRUE, NULL },
  726.     { "BMI", bmifl, flavorCount(bmifl), TRUE, NULL },
  727.     { "BNE", bnefl, flavorCount(bnefl), TRUE, NULL },
  728.     { "BPL", bplfl, flavorCount(bplfl), TRUE, NULL },
  729.     { "BRA", brafl, flavorCount(brafl), TRUE, NULL },
  730.         { "BREAK", breakfl, flavorCount(breakfl), TRUE, NULL },
  731.     { "BSET", bsetfl, flavorCount(bsetfl), TRUE, NULL },
  732.     { "BSR", bsrfl, flavorCount(bsrfl), TRUE, NULL },
  733.     { "BTST", btstfl, flavorCount(btstfl), TRUE, NULL },
  734.     { "BVC", bvcfl, flavorCount(bvcfl), TRUE, NULL },
  735.     { "BVS", bvsfl, flavorCount(bvsfl), TRUE, NULL },
  736.     { "CHK", chkfl, flavorCount(chkfl), TRUE, NULL },
  737.     { "CLR", clrfl, flavorCount(clrfl), TRUE, NULL },
  738.     { "CMP", cmpfl, flavorCount(cmpfl), TRUE, NULL },
  739.     { "CMPA", cmpafl, flavorCount(cmpafl), TRUE, NULL },
  740.     { "CMPI", cmpifl, flavorCount(cmpifl), TRUE, NULL },
  741.     { "CMPM", cmpmfl, flavorCount(cmpmfl), TRUE, NULL },
  742.     { "DBCC", dbccfl, flavorCount(dbccfl), TRUE, NULL },
  743.     { "DBCS", dbcsfl, flavorCount(dbcsfl), TRUE, NULL },
  744.     { "DBEQ", dbeqfl, flavorCount(dbeqfl), TRUE, NULL },
  745.     { "DBF", dbffl, flavorCount(dbffl), TRUE, NULL },
  746.     { "DBGE", dbgefl, flavorCount(dbgefl), TRUE, NULL },
  747.     { "DBGT", dbgtfl, flavorCount(dbgtfl), TRUE, NULL },
  748.     { "DBHI", dbhifl, flavorCount(dbhifl), TRUE, NULL },
  749.     { "DBHS", dbccfl, flavorCount(dbccfl), TRUE, NULL },
  750.     { "DBLE", dblefl, flavorCount(dblefl), TRUE, NULL },
  751.     { "DBLO", dbcsfl, flavorCount(dbcsfl), TRUE, NULL },
  752.     { "DBLS", dblsfl, flavorCount(dblsfl), TRUE, NULL },
  753.     { "DBLT", dbltfl, flavorCount(dbltfl), TRUE, NULL },
  754.     { "DBMI", dbmifl, flavorCount(dbmifl), TRUE, NULL },
  755.     { "DBNE", dbnefl, flavorCount(dbnefl), TRUE, NULL },
  756.     { "DBPL", dbplfl, flavorCount(dbplfl), TRUE, NULL },
  757.     { "DBRA", dbrafl, flavorCount(dbrafl), TRUE, NULL },
  758.     { "DBT", dbtfl, flavorCount(dbtfl), TRUE, NULL },
  759.     { "DBVC", dbvcfl, flavorCount(dbvcfl), TRUE, NULL },
  760.     { "DBVS", dbvsfl, flavorCount(dbvsfl), TRUE, NULL },
  761.     { "DC", NULL, 0, FALSE, dc },
  762.     { "DCB", NULL, 0, FALSE, dcb },
  763.     { "DIVS", divsfl, flavorCount(divsfl), TRUE, NULL },
  764.     { "DIVU", divufl, flavorCount(divufl), TRUE, NULL },
  765.     { "DS", NULL, 0, FALSE, ds },
  766.     { "END", NULL, 0, FALSE, End },
  767.     { "EOR", eorfl, flavorCount(eorfl), TRUE, NULL },
  768.     { "EORI", eorifl, flavorCount(eorifl), TRUE, NULL },
  769.     { "EQU", NULL, 0, FALSE, equ },
  770.     { "EXG", exgfl, flavorCount(exgfl), TRUE, NULL },
  771.     { "EXT", extfl, flavorCount(extfl), TRUE, NULL },
  772.     { "ILLEGAL", illegalfl, flavorCount(illegalfl), TRUE, NULL },
  773.     { "JMP", jmpfl, flavorCount(jmpfl), TRUE, NULL },
  774.     { "JSR", jsrfl, flavorCount(jsrfl), TRUE, NULL },
  775.     { "LEA", leafl, flavorCount(leafl), TRUE, NULL },
  776.     { "LINK", linkfl, flavorCount(linkfl), TRUE, NULL },
  777.     { "LSL", lslfl, flavorCount(lslfl), TRUE, NULL },
  778.     { "LSR", lsrfl, flavorCount(lsrfl), TRUE, NULL },
  779.     { "MOVE", movefl, flavorCount(movefl), TRUE, NULL },
  780.     { "MOVEA", moveafl, flavorCount(moveafl), TRUE, NULL },
  781.     { "MOVEC", movecfl, flavorCount(movecfl), TRUE, NULL },
  782.     { "MOVEM", NULL, 0, FALSE, movem },
  783.     { "MOVEP", movepfl, flavorCount(movepfl), TRUE, NULL },
  784.     { "MOVEQ", moveqfl, flavorCount(moveqfl), TRUE, NULL },
  785.     { "MOVES", movesfl, flavorCount(movesfl), TRUE, NULL },
  786.     { "MULS", mulsfl, flavorCount(mulsfl), TRUE, NULL },
  787.     { "MULU", mulufl, flavorCount(mulufl), TRUE, NULL },
  788.     { "NBCD", nbcdfl, flavorCount(nbcdfl), TRUE, NULL },
  789.     { "NEG", negfl, flavorCount(negfl), TRUE, NULL },
  790.     { "NEGX", negxfl, flavorCount(negxfl), TRUE, NULL },
  791.     { "NOP", nopfl, flavorCount(nopfl), TRUE, NULL },
  792.     { "NOT", notfl, flavorCount(notfl), TRUE, NULL },
  793.     { "OR", orfl, flavorCount(orfl), TRUE, NULL },
  794.     { "ORG", NULL, 0, FALSE, org },
  795.     { "ORI", orifl, flavorCount(orifl), TRUE, NULL },
  796.     { "PEA", peafl, flavorCount(peafl), TRUE, NULL },
  797.     { "REG", NULL, 0, FALSE, reg },
  798.     { "RESET", resetfl, flavorCount(resetfl), TRUE, NULL },
  799.     { "ROL", rolfl, flavorCount(rolfl), TRUE, NULL },
  800.     { "ROR", rorfl, flavorCount(rorfl), TRUE, NULL },
  801.     { "ROXL", roxlfl, flavorCount(roxlfl), TRUE, NULL },
  802.     { "ROXR", roxrfl, flavorCount(roxrfl), TRUE, NULL },
  803.     { "RTD", rtdfl, flavorCount(rtdfl), TRUE, NULL },
  804.     { "RTE", rtefl, flavorCount(rtefl), TRUE, NULL },
  805.     { "RTR", rtrfl, flavorCount(rtrfl), TRUE, NULL },
  806.     { "RTS", rtsfl, flavorCount(rtsfl), TRUE, NULL },
  807.     { "SBCD", sbcdfl, flavorCount(sbcdfl), TRUE, NULL },
  808.     { "SCC", sccfl, flavorCount(sccfl), TRUE, NULL },
  809.     { "SCS", scsfl, flavorCount(scsfl), TRUE, NULL },
  810.     { "SEQ", seqfl, flavorCount(seqfl), TRUE, NULL },
  811.     { "SET", NULL, 0, FALSE, set },
  812.     { "SF", sffl, flavorCount(sffl), TRUE, NULL },
  813.     { "SGE", sgefl, flavorCount(sgefl), TRUE, NULL },
  814.     { "SGT", sgtfl, flavorCount(sgtfl), TRUE, NULL },
  815.     { "SHI", shifl, flavorCount(shifl), TRUE, NULL },
  816.     { "SHS", sccfl, flavorCount(sccfl), TRUE, NULL },
  817.     { "SLE", slefl, flavorCount(slefl), TRUE, NULL },
  818.     { "SLO", scsfl, flavorCount(scsfl), TRUE, NULL },
  819.     { "SLS", slsfl, flavorCount(slsfl), TRUE, NULL },
  820.     { "SLT", sltfl, flavorCount(sltfl), TRUE, NULL },
  821.     { "SMI", smifl, flavorCount(smifl), TRUE, NULL },
  822.     { "SNE", snefl, flavorCount(snefl), TRUE, NULL },
  823.     { "SPL", splfl, flavorCount(splfl), TRUE, NULL },
  824.     { "ST", stfl, flavorCount(stfl), TRUE, NULL },
  825.     { "STOP", stopfl, flavorCount(stopfl), TRUE, NULL },
  826.     { "SUB", subfl, flavorCount(subfl), TRUE, NULL },
  827.     { "SUBA", subafl, flavorCount(subafl), TRUE, NULL },
  828.     { "SUBI", subifl, flavorCount(subifl), TRUE, NULL },
  829.     { "SUBQ", subqfl, flavorCount(subqfl), TRUE, NULL },
  830.     { "SUBX", subxfl, flavorCount(subxfl), TRUE, NULL },
  831.     { "SVC", svcfl, flavorCount(svcfl), TRUE, NULL },
  832.     { "SVS", svsfl, flavorCount(svsfl), TRUE, NULL },
  833.     { "SWAP", swapfl, flavorCount(swapfl), TRUE, NULL },
  834.     { "TAS", tasfl, flavorCount(tasfl), TRUE, NULL },
  835.     { "TRAP", trapfl, flavorCount(trapfl), TRUE, NULL },
  836.     { "TRAPV", trapvfl, flavorCount(trapvfl), TRUE, NULL },
  837.     { "TST", tstfl, flavorCount(tstfl), TRUE, NULL },
  838.     { "UNLK", unlkfl, flavorCount(unlkfl), TRUE, NULL }
  839.        };
  840.  
  841.  
  842. /* Declare a global variable containing the size of the instruction table */
  843.  
  844. /*                                    */
  845. /* Debugged 10/28/91 (Tan Phan):                    */
  846. /* "short int" to just "int"                        */
  847. /*                                    */
  848. int tableSize = sizeof(instTable)/sizeof(instruction);
  849.